home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / cat / zcalccrc.i < prev    next >
Text File  |  1997-10-26  |  16KB  |  371 lines
  1. IMPLEMENTATION MODULE ZCalcCrc;
  2.  
  3. FROM SYSTEM IMPORT LOAD, STORE, CODE, ADR, ASSEMBLER, CAST;
  4. (* FROM InOut IMPORT ReadString, WriteString, WriteLn, WriteCard, Read; *)
  5. FROM CatTypes IMPORT BigTextPtr;
  6. IMPORT AssFuncs;
  7.  
  8. PROCEDURE CalcIdCrc (REF str: ARRAY OF CHAR): CARDINAL;
  9. (* Berechnet eine CRC ber eine ID. Dabei wird der domain-part
  10.  * der ID nach Upcase gewandelt, da dieser case-insensitiv
  11.  * behandelt werden soll
  12.  *)
  13.   VAR (*$Reg*) l : CARDINAL;
  14.       tmp        : ARRAY [0..511] OF CHAR;
  15. BEGIN
  16.   l := AssFuncs.CopyId (str, tmp);
  17.   RETURN CalcCrcArray (ADR(tmp), l);
  18. END CalcIdCrc;
  19.  
  20. PROCEDURE CalcCrc(REF str : ARRAY OF CHAR):CARDINAL;
  21. (*
  22. VAR d,e,i,temp : CARDINAL;
  23. BEGIN
  24.   d := 0;
  25.   e := 0;
  26.   i := 0;
  27.   WHILE str[i] # 0C DO
  28.     temp := XOR(ORD(str[i]), d) MOD 256;
  29. (* WriteString('temp:');WriteCard(temp, 8); *)
  30.     temp := XOR(temp, temp DIV 16) MOD 256;
  31. (* WriteCard(temp, 8);WriteLn; *)
  32.     d := XOR(XOR((temp * 16) MOD 256, temp DIV 8), e) MOD 256;
  33. (* WriteString('e:');WriteCard(d, 8);WriteLn; *)
  34.     e := XOR(temp, (temp * 32) MOD 256) MOD 256;
  35. (* WriteString('d:');WriteCard(e, 8);WriteLn; *)
  36.     INC(i);
  37.   END;
  38.   RETURN d * 256 + e
  39. *)
  40. BEGIN
  41. (*$W-*)
  42.   RETURN CalcCrcArray(ADR(str), LENGTH(str));
  43. (*$W=*)
  44. END CalcCrc;
  45. (*
  46. PROCEDURE CalcCrcArray(a : BigTextPtr; howMuch : CARDINAL):CARDINAL;
  47. VAR d,e,i,temp : CARDINAL;
  48.  
  49.   PROCEDURE XOR(c1,c2 : CARDINAL):CARDINAL;
  50.     VAR res : CARDINAL;
  51.   BEGIN
  52.     LOAD (c1, 0);
  53.     LOAD (c2, 1);
  54.     CODE(0B141H);
  55.     STORE (1,res);
  56.     RETURN res
  57.   END XOR;
  58.  
  59. BEGIN
  60.   d := 0;
  61.   e := 0;
  62.   IF howMuch = 0 THEN RETURN 0 END;
  63.   FOR i := 0 TO howMuch-1 DO
  64.     temp := XOR(ORD(a^[i]), d) MOD 256;
  65.     temp := XOR(temp, temp DIV 16) MOD 256;
  66.     d := XOR(XOR((temp * 16) MOD 256, temp DIV 8), e) MOD 256;
  67.     e := XOR(temp, (temp * 32) MOD 256) MOD 256;
  68.   END;
  69.   RETURN d * 256 + e
  70. END CalcCrcArray;
  71. *)
  72.  
  73. (*$L-,Z+*)
  74. PROCEDURE CalcCrcArray (a : BigTextPtr; howMuch : CARDINAL):CARDINAL;
  75. BEGIN
  76.   ASSEMBLER
  77.     MOVEM.L     D3-D7,-(SP)
  78.     MOVEQ       #0,D0   ; d
  79.     MOVEQ       #0,D1   ; e
  80.     MOVE.W      -(A3),D2  ; Z„hler
  81.     TST.W       D2              ; D2 = 0
  82.     BEQ.S       ret             ; Direkt 0 zurckgeben
  83.     MOVEQ       #0,D3           ; i in Schleife
  84.     MOVE.L      -(A3),A0        ; Basisadresse fr String
  85. loop:
  86.     CMP.W       D2,D3           ; Schleifenende erreicht?
  87.     BEQ.S       retx
  88.     MOVE.W      D0,D4           ; D4 =  temp
  89. ;     temp := XOR(ORD(a^[i]), d) MOD 256;
  90.     MOVE.B      0(A0,D3.W),D5
  91.     EXT.W       D5
  92.     EOR.W       D5,D4
  93.     ANDI.W      #$FF,D4
  94. ;     temp := XOR(temp, temp DIV 16) MOD 256;
  95.     MOVE.W      D4,D5
  96.     LSR.W       #4,D5
  97.     EOR.W       D5,D4
  98.     ANDI.W      #$FF,D4
  99. ;     d := XOR(XOR((temp * 16) MOD 256, temp DIV 8), e) MOD 256;
  100.     MOVE.W      D4,D5
  101.     MOVE.W      D4,D0
  102.     LSL.W       #4,D5
  103.     ANDI.W      #$FF,D5
  104.     LSR.W       #3,D0
  105.     EOR.W       D5,D0
  106.     EOR.W       D1,D0
  107.     ANDI.W      #$FF,D0
  108. ;     e := XOR(temp, (temp * 32) MOD 256) MOD 256;
  109.     MOVE.W      D4,D5
  110.     LSL.W       #5,D5
  111.     ANDI.W      #$FF,D5
  112.     EOR.W       D5,D4
  113.     ANDI.W      #$FF,D4
  114.     MOVE.W      D4,D1
  115.     ADDQ.W      #1,D3
  116.     BRA.S       loop
  117. retx:
  118.     LSL.W       #8,D0
  119.     ADD.W       D1,D0
  120. ret:
  121.     MOVEM.L     (SP)+,D3-D7
  122.   END;
  123. END CalcCrcArray;
  124. (*$L=*)
  125.  
  126. (* Crc - 32 BIT ANSI X3.66 CRC checksum files *)
  127. (* modified by wr 25-8-93 *)
  128.  
  129. (**********************************************************************\
  130. |* Demonstration program to compute the 32-bit CRC used as the frame  *|
  131. |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71     *|
  132. |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level     *|
  133. |* protocol).  The 32-bit FCS was added via the Federal Register,     *|
  134. |* 1 June 1982, p.23798.  I presume but don't know for certain that   *|
  135. |* this polynomial is or will be included in CCITT V.41, which        *|
  136. |* defines the 16-bit CRC (often called CRC-CCITT) polynomial.  FIPS  *|
  137. |* PUB 78 says that the 32-bit FCS reduces otherwise undetected       *|
  138. |* errors by a factor of 10^-5 over 16-bit FCS.                       *|
  139. \**********************************************************************)
  140.  
  141. (* Copyright (C) 1986 Gary S. Brown.  You may use this program, or
  142.    code or tables extracted from it, as desired without restriction.*)
  143.  
  144. (* First, the polynomial itself and its table of feedback terms.  The  *)
  145. (* polynomial is                                                       *)
  146. (* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 *)
  147. (* Note that we take it "backwards" and put the highest-order term in  *)
  148. (* the lowest-order bit.  The X^32 term is "implied"; the LSB is the   *)
  149. (* X^31 term, etc.  The X^0 term (usually shown as "+1") results in    *)
  150. (* the MSB being 1.                                                    *)
  151.  
  152. (* Note that the usual hardware shift register implementation, which   *)
  153. (* is what we're using (we're merely optimizing it by doing eight-bit  *)
  154. (* chunks at a time) shifts bits into the lowest-order term.  In our   *)
  155. (* implementation, that means shifting towards the right.  Why do we   *)
  156. (* do it this way?  Because the calculated CRC must be transmitted in  *)
  157. (* order from highest-order term to lowest-order term.  UARTs transmit *)
  158. (* characters in order from LSB to MSB.  By storing the CRC this way,  *)
  159. (* we hand it to the UART in the order low-byte to high-byte; the UART *)
  160. (* sends each low-bit to hight-bit; and the result is transmission bit *)
  161. (* by bit from highest- to lowest-order term without requiring any bit *)
  162. (* shuffling on our part.  Reception works similarly.                  *)
  163.  
  164. (* The feedback terms table consists of 256, 32-bit entries.  Notes:   *)
  165. (*                                                                     *)
  166. (*  1. The table can be generated at runtime if desired; code to do so *)
  167. (*     is shown later.  It might not be obvious, but the feedback      *)
  168. (*     terms simply represent the results of eight shift/xor opera-    *)
  169. (*     tions for all combinations of data and CRC register values.     *)
  170. (*                                                                     *)
  171. (*  2. The CRC accumulation logic is the same for all CRC polynomials, *)
  172. (*     be they sixteen or thirty-two bits wide.  You simply choose the *)
  173. (*     appropriate table.  Alternatively, because the table can be     *)
  174. (*     generated at runtime, you can start by generating the table for *)
  175. (*     the polynomial in question and use exactly the same "updcrc",   *)
  176. (*     if your application needn't simultaneously handle two CRC       *)
  177. (*     polynomials.  (Note, however, that XMODEM is strange.)          *)
  178. (*                                                                     *)
  179. (*  3. For 16-bit CRCs, the table entries need be only 16 bits wide;   *)
  180. (*     of course, 32-bit entries work OK if the high 16 bits are zero. *)
  181. (*                                                                     *)
  182. (*  4. The values must be right-shifted by eight bits by the "updcrc"  *)
  183. (*     logic; the shift must be unsigned (bring in zeroes).  On some   *)
  184. (*     hardware you could probably optimize the shift in assembler by  *)
  185. (*     using byte-swap instructions.                                   *)
  186.  
  187. (*
  188. TYPE crcConstArray = ARRAY [0..255] OF LONGCARD;
  189.  
  190. CONST crc32tab = crcConstArray { (* CRC polynomial 0xedb88320 *)
  191. $00000000L, $77073096L, $ee0e612cL, $990951baL, $076dc419L, $706af48fL,
  192. $e963a535L, $9e6495a3L, $0edb8832L, $79dcb8a4L, $e0d5e91eL, $97d2d988L,
  193. $09b64c2bL, $7eb17cbdL, $e7b82d07L, $90bf1d91L, $1db71064L, $6ab020f2L,
  194. $f3b97148L, $84be41deL, $1adad47dL, $6ddde4ebL, $f4d4b551L, $83d385c7L,
  195. $136c9856L, $646ba8c0L, $fd62f97aL, $8a65c9ecL, $14015c4fL, $63066cd9L,
  196. $fa0f3d63L, $8d080df5L, $3b6e20c8L, $4c69105eL, $d56041e4L, $a2677172L,
  197. $3c03e4d1L, $4b04d447L, $d20d85fdL, $a50ab56bL, $35b5a8faL, $42b2986cL,
  198. $dbbbc9d6L, $acbcf940L, $32d86ce3L, $45df5c75L, $dcd60dcfL, $abd13d59L,
  199. $26d930acL, $51de003aL, $c8d75180L, $bfd06116L, $21b4f4b5L, $56b3c423L,
  200. $cfba9599L, $b8bda50fL, $2802b89eL, $5f058808L, $c60cd9b2L, $b10be924L,
  201. $2f6f7c87L, $58684c11L, $c1611dabL, $b6662d3dL, $76dc4190L, $01db7106L,
  202. $98d220bcL, $efd5102aL, $71b18589L, $06b6b51fL, $9fbfe4a5L, $e8b8d433L,
  203. $7807c9a2L, $0f00f934L, $9609a88eL, $e10e9818L, $7f6a0dbbL, $086d3d2dL,
  204. $91646c97L, $e6635c01L, $6b6b51f4L, $1c6c6162L, $856530d8L, $f262004eL,
  205. $6c0695edL, $1b01a57bL, $8208f4c1L, $f50fc457L, $65b0d9c6L, $12b7e950L,
  206. $8bbeb8eaL, $fcb9887cL, $62dd1ddfL, $15da2d49L, $8cd37cf3L, $fbd44c65L,
  207. $4db26158L, $3ab551ceL, $a3bc0074L, $d4bb30e2L, $4adfa541L, $3dd895d7L,
  208. $a4d1c46dL, $d3d6f4fbL, $4369e96aL, $346ed9fcL, $ad678846L, $da60b8d0L,
  209. $44042d73L, $33031de5L, $aa0a4c5fL, $dd0d7cc9L, $5005713cL, $270241aaL,
  210. $be0b1010L, $c90c2086L, $5768b525L, $206f85b3L, $b966d409L, $ce61e49fL,
  211. $5edef90eL, $29d9c998L, $b0d09822L, $c7d7a8b4L, $59b33d17L, $2eb40d81L,
  212. $b7bd5c3bL, $c0ba6cadL, $edb88320L, $9abfb3b6L, $03b6e20cL, $74b1d29aL,
  213. $ead54739L, $9dd277afL, $04db2615L, $73dc1683L, $e3630b12L, $94643b84L,
  214. $0d6d6a3eL, $7a6a5aa8L, $e40ecf0bL, $9309ff9dL, $0a00ae27L, $7d079eb1L,
  215. $f00f9344L, $8708a3d2L, $1e01f268L, $6906c2feL, $f762575dL, $806567cbL,
  216. $196c3671L, $6e6b06e7L, $fed41b76L, $89d32be0L, $10da7a5aL, $67dd4accL,
  217. $f9b9df6fL, $8ebeeff9L, $17b7be43L, $60b08ed5L, $d6d6a3e8L, $a1d1937eL,
  218. $38d8c2c4L, $4fdff252L, $d1bb67f1L, $a6bc5767L, $3fb506ddL, $48b2364bL,
  219. $d80d2bdaL, $af0a1b4cL, $36034af6L, $41047a60L, $df60efc3L, $a867df55L,
  220. $316e8eefL, $4669be79L, $cb61b38cL, $bc66831aL, $256fd2a0L, $5268e236L,
  221. $cc0c7795L, $bb0b4703L, $220216b9L, $5505262fL, $c5ba3bbeL, $b2bd0b28L,
  222. $2bb45a92L, $5cb36a04L, $c2d7ffa7L, $b5d0cf31L, $2cd99e8bL, $5bdeae1dL,
  223. $9b64c2b0L, $ec63f226L, $756aa39cL, $026d930aL, $9c0906a9L, $eb0e363fL,
  224. $72076785L, $05005713L, $95bf4a82L, $e2b87a14L, $7bb12baeL, $0cb61b38L,
  225. $92d28e9bL, $e5d5be0dL, $7cdcefb7L, $0bdbdf21L, $86d3d2d4L, $f1d4e242L,
  226. $68ddb3f8L, $1fda836eL, $81be16cdL, $f6b9265bL, $6fb077e1L, $18b74777L,
  227. $88085ae6L, $ff0f6a70L, $66063bcaL, $11010b5cL, $8f659effL, $f862ae69L,
  228. $616bffd3L, $166ccf45L, $a00ae278L, $d70dd2eeL, $4e048354L, $3903b3c2L,
  229. $a7672661L, $d06016f7L, $4969474dL, $3e6e77dbL, $aed16a4aL, $d9d65adcL,
  230. $40df0b66L, $37d83bf0L, $a9bcae53L, $debb9ec5L, $47b2cf7fL, $30b5ffe9L,
  231. $bdbdf21cL, $cabac28aL, $53b39330L, $24b4a3a6L, $bad03605L, $cdd70693L,
  232. $54de5729L, $23d967bfL, $b3667a2eL, $c4614ab8L, $5d681b02L, $2a6f2b94L,
  233. $b40bbe37L, $c30c8ea1L, $5a05df1bL, $2d02ef8dL
  234. };
  235.  
  236. (*$L-,Z+*)
  237. PROCEDURE XOR(c1,c2 : LONGCARD):LONGCARD;
  238. BEGIN
  239.   ASSEMBLER
  240.     MOVE.L  -(A3),D1
  241.     MOVE.L  -(A3),D0
  242.     EOR.L   D1,D0
  243.   END;
  244. END XOR;
  245. (*$L=*)
  246.  
  247. PROCEDURE crc32(adr: BigTextPtr; len: CARDINAL): LONGCARD;
  248.   VAR (*$Reg*) oldcrc32 : LONGCARD;
  249.       (*$Reg*) i        : CARDINAL;
  250. BEGIN
  251.  
  252.     oldcrc32 := $FFFFFFFF;
  253.     FOR i := len TO 0 BY -1 DO
  254.         oldcrc32 := XOR(crc32tab[ SHORT(XOR(oldcrc32, LONG(ORD(adr^[0]))) MOD 256)], oldcrc32 DIV 256);
  255.         INC (adr);
  256.     END;
  257.     
  258.     RETURN $ffffffff - oldcrc32;
  259.     (*
  260.     RETURN ~oldcrc32;
  261.     *)
  262. END crc32;
  263. *)
  264.  
  265. (*$L-,R-,S-,Z+*)
  266. PROCEDURE crc32(adr: BigTextPtr; len: CARDINAL): LONGCARD;
  267.   VAR (*$Reg*) oldcrc32 : LONGCARD;
  268.       (*$Reg*) i        : LONGCARD;
  269. BEGIN
  270.   ASSEMBLER
  271.     MOVE.W  -(A3),D0    ; len
  272.     MOVE.L  -(A3),A0    ; adr
  273.     LEA     crctab(PC),A1 ; crc-Tabelle
  274.     MOVEQ   #-1,D1      ; oldcrc initialisieren
  275.     MOVEQ   #0,D2       ; Zwischenregister
  276.     SUBQ.W  #1,D0       ; -1 wegen DBRA
  277.     
  278. loop:
  279.     MOVE.L  D1,D3       ; xor zwischen oldcrc und adr^ berechnen
  280.     MOVE.B  (A0)+,D2    ; Zeichen nach D2
  281.     EOR.L   D2,D3       ; Ergebnis in D3
  282.     AND.W   #$FF,D3     ; MOD 256
  283.     LSL.W   #2,D3       ; Ulong-Eintr„ge, *4
  284.     MOVE.L  0(A1,D3.W),D2 ; Wert aus Tabelle nach D2
  285.     LSR.L   #8,D1       ; oldcrc DIV 256
  286.     EOR.L   D2,D1       ; XOR zwischen Tabellenwert und oldcrc DIV 256
  287.     DBRA    D0,loop
  288.     
  289.     MOVE.L  D1,D0
  290.     NOT.L   D0
  291.     RTS
  292.  
  293. crctab:
  294. DC.L    $00000000L, $77073096L, $ee0e612cL, $990951baL, $076dc419L, $706af48fL,
  295. $e963a535L, $9e6495a3L, $0edb8832L, $79dcb8a4L, $e0d5e91eL, $97d2d988L,
  296. $09b64c2bL, $7eb17cbdL, $e7b82d07L, $90bf1d91L, $1db71064L, $6ab020f2L,
  297. $f3b97148L, $84be41deL, $1adad47dL, $6ddde4ebL, $f4d4b551L, $83d385c7L,
  298. $136c9856L, $646ba8c0L, $fd62f97aL, $8a65c9ecL, $14015c4fL, $63066cd9L,
  299. $fa0f3d63L, $8d080df5L, $3b6e20c8L, $4c69105eL, $d56041e4L, $a2677172L,
  300. $3c03e4d1L, $4b04d447L, $d20d85fdL, $a50ab56bL, $35b5a8faL, $42b2986cL,
  301. $dbbbc9d6L, $acbcf940L, $32d86ce3L, $45df5c75L, $dcd60dcfL, $abd13d59L,
  302. $26d930acL, $51de003aL, $c8d75180L, $bfd06116L, $21b4f4b5L, $56b3c423L,
  303. $cfba9599L, $b8bda50fL, $2802b89eL, $5f058808L, $c60cd9b2L, $b10be924L,
  304. $2f6f7c87L, $58684c11L, $c1611dabL, $b6662d3dL, $76dc4190L, $01db7106L,
  305. $98d220bcL, $efd5102aL, $71b18589L, $06b6b51fL, $9fbfe4a5L, $e8b8d433L,
  306. $7807c9a2L, $0f00f934L, $9609a88eL, $e10e9818L, $7f6a0dbbL, $086d3d2dL,
  307. $91646c97L, $e6635c01L, $6b6b51f4L, $1c6c6162L, $856530d8L, $f262004eL,
  308. $6c0695edL, $1b01a57bL, $8208f4c1L, $f50fc457L, $65b0d9c6L, $12b7e950L,
  309. $8bbeb8eaL, $fcb9887cL, $62dd1ddfL, $15da2d49L, $8cd37cf3L, $fbd44c65L,
  310. $4db26158L, $3ab551ceL, $a3bc0074L, $d4bb30e2L, $4adfa541L, $3dd895d7L,
  311. $a4d1c46dL, $d3d6f4fbL, $4369e96aL, $346ed9fcL, $ad678846L, $da60b8d0L,
  312. $44042d73L, $33031de5L, $aa0a4c5fL, $dd0d7cc9L, $5005713cL, $270241aaL,
  313. $be0b1010L, $c90c2086L, $5768b525L, $206f85b3L, $b966d409L, $ce61e49fL,
  314. $5edef90eL, $29d9c998L, $b0d09822L, $c7d7a8b4L, $59b33d17L, $2eb40d81L,
  315. $b7bd5c3bL, $c0ba6cadL, $edb88320L, $9abfb3b6L, $03b6e20cL, $74b1d29aL,
  316. $ead54739L, $9dd277afL, $04db2615L, $73dc1683L, $e3630b12L, $94643b84L,
  317. $0d6d6a3eL, $7a6a5aa8L, $e40ecf0bL, $9309ff9dL, $0a00ae27L, $7d079eb1L,
  318. $f00f9344L, $8708a3d2L, $1e01f268L, $6906c2feL, $f762575dL, $806567cbL,
  319. $196c3671L, $6e6b06e7L, $fed41b76L, $89d32be0L, $10da7a5aL, $67dd4accL,
  320. $f9b9df6fL, $8ebeeff9L, $17b7be43L, $60b08ed5L, $d6d6a3e8L, $a1d1937eL,
  321. $38d8c2c4L, $4fdff252L, $d1bb67f1L, $a6bc5767L, $3fb506ddL, $48b2364bL,
  322. $d80d2bdaL, $af0a1b4cL, $36034af6L, $41047a60L, $df60efc3L, $a867df55L,
  323. $316e8eefL, $4669be79L, $cb61b38cL, $bc66831aL, $256fd2a0L, $5268e236L,
  324. $cc0c7795L, $bb0b4703L, $220216b9L, $5505262fL, $c5ba3bbeL, $b2bd0b28L,
  325. $2bb45a92L, $5cb36a04L, $c2d7ffa7L, $b5d0cf31L, $2cd99e8bL, $5bdeae1dL,
  326. $9b64c2b0L, $ec63f226L, $756aa39cL, $026d930aL, $9c0906a9L, $eb0e363fL,
  327. $72076785L, $05005713L, $95bf4a82L, $e2b87a14L, $7bb12baeL, $0cb61b38L,
  328. $92d28e9bL, $e5d5be0dL, $7cdcefb7L, $0bdbdf21L, $86d3d2d4L, $f1d4e242L,
  329. $68ddb3f8L, $1fda836eL, $81be16cdL, $f6b9265bL, $6fb077e1L, $18b74777L,
  330. $88085ae6L, $ff0f6a70L, $66063bcaL, $11010b5cL, $8f659effL, $f862ae69L,
  331. $616bffd3L, $166ccf45L, $a00ae278L, $d70dd2eeL, $4e048354L, $3903b3c2L,
  332. $a7672661L, $d06016f7L, $4969474dL, $3e6e77dbL, $aed16a4aL, $d9d65adcL,
  333. $40df0b66L, $37d83bf0L, $a9bcae53L, $debb9ec5L, $47b2cf7fL, $30b5ffe9L,
  334. $bdbdf21cL, $cabac28aL, $53b39330L, $24b4a3a6L, $bad03605L, $cdd70693L,
  335. $54de5729L, $23d967bfL, $b3667a2eL, $c4614ab8L, $5d681b02L, $2a6f2b94L,
  336. $b40bbe37L, $c30c8ea1L, $5a05df1bL, $2d02ef8dL
  337.   END;
  338. END crc32;
  339. (*$L=*)
  340.  
  341. (*
  342. VAR str : ARRAY[0..80] OF CHAR;
  343. VAR str2 : ARRAY[0..80] OF CHAR;
  344.  
  345. BEGIN
  346.   REPEAT
  347.   ReadString(str); WriteLn;
  348.   WriteString(str);WriteLn;
  349.   WriteCard(CalcCrc(str),8); WriteLn;
  350.   WriteCard(CalcIdCrc(str),8); WriteLn;
  351.   Read(str[0]);
  352.   UNTIL str[0] = ' ';
  353.   REPEAT
  354.   ReadString(str); WriteLn;
  355.   WriteString(str);WriteLn;
  356.   ReadString(str2); WriteLn;
  357.   WriteString(str2);WriteLn;
  358.   WriteString ('alte: '); WriteString (str); WriteLn;
  359.   WriteString ('neue: '); WriteString (str2); WriteLn;
  360.   IF AssFuncs.CmpId (str, str2)
  361.   THEN
  362.     WriteString ('sind gleich'); 
  363.   ELSE
  364.     WriteString ('sind nicht gleich');
  365.   END;
  366.   WriteLn;
  367.   Read(str[0]);
  368.   UNTIL str[0] = ' ';
  369.   *)
  370. END ZCalcCrc.
  371.